#ifndef __WIZ_BNF_ACTOR_COMPOSITE_HPP__SHANHAOBO_19800429__
#define __WIZ_BNF_ACTOR_COMPOSITE_HPP__SHANHAOBO_19800429__

#include "../../Base/WizBase.hpp"

namespace Wiz
{
    namespace BNF
    {
        namespace Actor
        {
            template <typename ActorT, typename TupleT>
            struct Result;

            template <typename BaseT>
            struct Type;

            template <typename T>
            struct As;
        } /// end of namespace Actor

        ///////////////////////////////////
        namespace Composite
        {
            ///////////////////////////////////////////////////////////////////////////////
            ///////////////////////////////////////////////////////////////////////////////
            ///////////////////////////////////////////////////////////////////////////////
            template <typename OperationT, typename TupleT>
            struct Result0
            {
                typedef typename OperationT::tResult                                                                        tType;
            };

            template <typename OperationT, typename TupleT, typename T0>
            struct Result1
            {
                typedef typename OperationT::template Result<typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain>::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1>
            struct Result2
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2>
            struct Result3
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3>
            struct Result4
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3, typename T4>
            struct Result5
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
            struct Result6
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
            struct Result7
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
            struct Result8
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T7, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
            struct Result9
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T7, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T8, TupleT>::tPlain
                >::tType tType;
            };

            template <typename OperationT, typename TupleT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
            struct Result10
            {
                typedef typename OperationT::template Result<
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T7, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T8, TupleT>::tPlain,
                    typename ::Wiz::BNF::Actor::Result<T9, TupleT>::tPlain
                >::tType tType;
            };
            ///////////////////////////////////////////////////////////////////////////////
            ///////////////////////////////////////////////////////////////////////////////
            ///////////////////////////////////////////////////////////////////////////////
            template
            <
                typename OperationT,
                typename T0 = ::Wiz::Null::Type,
                typename T1 = ::Wiz::Null::Type,
                typename T2 = ::Wiz::Null::Type,
                typename T3 = ::Wiz::Null::Type,
                typename T4 = ::Wiz::Null::Type,
                typename T5 = ::Wiz::Null::Type,
                typename T6 = ::Wiz::Null::Type,
                typename T7 = ::Wiz::Null::Type,
                typename T8 = ::Wiz::Null::Type,
                typename T9 = ::Wiz::Null::Type,
                typename NU = ::Wiz::Null::Type
             > struct Type;

            template <typename OperationT>
            struct Type<OperationT, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper) : m_Operation(Oper)
                {

                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result0<OperationT, TupleT>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const&) const
                {
                    return m_Operation();
                }

                mutable OperationT m_Operation;
            };

            template <typename OperationT, typename T0>
            struct Type<OperationT, T0, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0) : m_Operation(Oper), m_T0(t0)
                {

                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result1<OperationT, TupleT, T0>::tType tType;
                };

                template <typename TupleT>
                typename OperationT::tResult Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    return m_Operation(R0);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
            };

            template <typename OperationT, typename T0, typename T1>
            struct Type<OperationT, T0, T1, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1) : m_Operation(Oper), m_T0(t0), m_T1(t1)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result2<OperationT, TupleT, T0, T1>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType
                Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    return m_Operation(R0, R1);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
            };

            template <typename OperationT, typename T0, typename T1, typename T2>
            struct Type<OperationT, T0, T1, T2, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2) : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result3<OperationT, TupleT, T0, T1, T2>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    return m_Operation(R0, R1, R2);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3>
            struct Type<OperationT, T0, T1, T2, T3, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3) : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result4<OperationT, TupleT, T0, T1, T2, T3>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3, typename T4>
            struct Type<OperationT, T0, T1, T2, T3, T4, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4) : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3), m_T4(t4)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result5<OperationT, TupleT, T0, T1, T2, T3, T4>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tType R4 = m_T4.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3, R4);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
                T4 m_T4;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
            struct Type<OperationT, T0, T1, T2, T3, T4, T5, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5)
                    : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3), m_T4(t4), m_T5(t5)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result6<OperationT, TupleT, T0, T1, T2, T3, T4, T5>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tType R4 = m_T4.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tType R5 = m_T5.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3, R4, R5);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
                T4 m_T4;
                T5 m_T5;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
            struct Type<OperationT, T0, T1, T2, T3, T4, T5, T6, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6)
                    : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3), m_T4(t4), m_T5(t5), m_T6(t6)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result7<OperationT, TupleT, T0, T1, T2, T3, T4, T5, T6>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tType R4 = m_T4.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tType R5 = m_T5.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tType R6 = m_T6.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3, R4, R5, R6);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
                T4 m_T4;
                T5 m_T5;
                T6 m_T6;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
            struct Type<OperationT, T0, T1, T2, T3, T4, T5, T6, T7, ::Wiz::Null::Type, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6, T7 const& t7)
                    : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3), m_T4(t4), m_T5(t5), m_T6(t6), m_T7(t7)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result8<OperationT, TupleT, T0, T1, T2, T3, T4, T5, T6, T7>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tType R4 = m_T4.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tType R5 = m_T5.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tType R6 = m_T6.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T7, TupleT>::tType R7 = m_T7.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3, R4, R5, R6, R7);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
                T4 m_T4;
                T5 m_T5;
                T6 m_T6;
                T7 m_T7;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
            struct Type<OperationT, T0, T1, T2, T3, T4, T5, T6, T7, T8, ::Wiz::Null::Type, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6, T7 const& t7, T8 const& t8)
                    : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3), m_T4(t4), m_T5(t5), m_T6(t6), m_T7(t7), m_T8(t8)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result9<OperationT, TupleT, T0, T1, T2, T3, T4, T5, T6, T7, T8>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tType R4 = m_T4.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tType R5 = m_T5.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tType R6 = m_T6.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T7, TupleT>::tType R7 = m_T7.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T8, TupleT>::tType R8 = m_T8.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3, R4, R5, R6, R7, R8);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
                T4 m_T4;
                T5 m_T5;
                T6 m_T6;
                T7 m_T7;
                T8 m_T8;
            };

            template <typename OperationT, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
            struct Type<OperationT, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ::Wiz::Null::Type>
            {
                Type(OperationT const& Oper, T0 const& t0, T1 const& t1, T2 const& t2, T3 const& t3, T4 const& t4, T5 const& t5, T6 const& t6, T7 const& t7, T8 const& t8, T9 const& t9)
                    : m_Operation(Oper), m_T0(t0), m_T1(t1), m_T2(t2), m_T3(t3), m_T4(t4), m_T5(t5), m_T6(t6), m_T7(t7), m_T8(t8), m_T9(t9)
                {
                }

                template <typename TupleT>
                struct Result
                {
                    typedef typename ::Wiz::BNF::Composite::Result10<OperationT, TupleT, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::tType tType;
                };

                template <typename TupleT>
                typename ::Wiz::BNF::Actor::Result<Type, TupleT>::tType Evaluate(TupleT const& Args) const
                {
                    typename ::Wiz::BNF::Actor::Result<T0, TupleT>::tType R0 = m_T0.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T1, TupleT>::tType R1 = m_T1.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T2, TupleT>::tType R2 = m_T2.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T3, TupleT>::tType R3 = m_T3.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T4, TupleT>::tType R4 = m_T4.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T5, TupleT>::tType R5 = m_T5.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T6, TupleT>::tType R6 = m_T6.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T7, TupleT>::tType R7 = m_T7.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T8, TupleT>::tType R8 = m_T8.Evaluate(Args);
                    typename ::Wiz::BNF::Actor::Result<T9, TupleT>::tType R9 = m_T9.Evaluate(Args);
                    return m_Operation(R0, R1, R2, R3, R4, R5, R6, R7, R8, R9);
                }

                mutable OperationT m_Operation;
                T0 m_T0;
                T1 m_T1;
                T2 m_T2;
                T3 m_T3;
                T4 m_T4;
                T5 m_T5;
                T6 m_T6;
                T7 m_T7;
                T8 m_T8;
                T9 m_T9;
            };

            ////////////////////////////////////////////////////////////////////////////////////////////
            ////////////////////////////////////////////////////////////////////////////////////////////
            ////////////////////////////////////////////////////////////////////////////////////////////
            template <
                typename OperationT
                ,   typename T0 = ::Wiz::Null::Type
                ,   typename T1 = ::Wiz::Null::Type
                ,   typename T2 = ::Wiz::Null::Type
                ,   typename T3 = ::Wiz::Null::Type
                ,   typename T4 = ::Wiz::Null::Type
                ,   typename T5 = ::Wiz::Null::Type
                ,   typename T6 = ::Wiz::Null::Type
                ,   typename T7 = ::Wiz::Null::Type
                ,   typename T8 = ::Wiz::Null::Type
                ,   typename T9 = ::Wiz::Null::Type
            >
            struct MakeComposite {

                typedef ::Wiz::BNF::Composite::Type<OperationT
                    ,   typename ::Wiz::BNF::Actor::As<T0>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T1>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T2>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T3>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T4>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T5>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T6>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T7>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T8>::tType
                    ,   typename ::Wiz::BNF::Actor::As<T9>::tType
                > tComposite;

                typedef ::Wiz::BNF::Actor::Type<tComposite> tType;
            };
            template <typename OperationT, typename BaseT>
            struct MakeUnary
            {

                typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, ::Wiz::BNF::Actor::Type<BaseT>>::tType tType;

                static tType Construct(::Wiz::BNF::Actor::Type<BaseT> const& Arg)
                {
                    typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, ::Wiz::BNF::Actor::Type<BaseT> >::tComposite tReturn;

                    return tReturn(OperationT(), Arg);
                }
            };

            template <typename OperationT, typename BaseT, typename RhsT>
            struct MakeBinary1
            {
                typedef ::Wiz::BNF::Actor::Type<BaseT>                              tBaseActor;
                typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, tBaseActor, RhsT>::tType   tType;

                static tType Construct(tBaseActor const& Lhs, RhsT const& Rhs)
                {
                    typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, tBaseActor, RhsT>::tComposite tReturn;

                    return tReturn(OperationT(), Lhs, ::Wiz::BNF::Actor::As<RhsT>::Convert(Rhs));
                }
            };

            template <typename OperationT, typename LhrT, typename BaseT>
            struct MakeBinary2
            {
                typedef ::Wiz::BNF::Actor::Type<BaseT>                              tBaseActor;
                typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, LhrT, tBaseActor>::tType   tType;

                static tType Construct(LhrT const& Lhs, tBaseActor const& Rhs)
                {
                    typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, LhrT, tBaseActor>::tComposite tReturn;

                    return tReturn(OperationT(), ::Wiz::BNF::Actor::As<LhrT>::Convert(Lhs), Rhs);
                }
            };

            template <typename OperationT, typename BaseLhsT, typename BaseRhsT>
            struct MakeBinary3
            {
                typedef ::Wiz::BNF::Actor::Type<BaseLhsT>                              tBaseLhsActor;
                typedef ::Wiz::BNF::Actor::Type<BaseRhsT>                              tBaseRhsActor;
                typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, tBaseLhsActor, tBaseRhsActor>::tType   tType;

                static tType Construct(tBaseLhsActor const& Lhs, tBaseRhsActor const& Rhs)
                {
                    typedef typename ::Wiz::BNF::Composite::MakeComposite<OperationT, tBaseLhsActor, tBaseRhsActor>::tComposite tReturn;

                    return tReturn(OperationT(), Lhs, Rhs);
                }
            };
            //////////////////////////////////////////////////////////////////////////////////////////
            ////////////////////////////////////////////////////////////////////////////////////////////
            ////////////////////////////////////////////////////////////////////////////////////////////
        } /// end of namespace Composite
    } /// end of namespace BNF
} /// end of namespace Wiz

#endif /*__WIZ_BNF_ACTOR_COMPOSITE_HPP__SHANHAOBO_19800429__*/
